home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d21 / calcdv.arc / CALCDV.C < prev    next >
Text File  |  1988-03-12  |  26KB  |  725 lines
  1. /************************************************************************
  2.  *                                    *
  3.  *      A Simple Calculator for Desqview                *
  4.  *                                    *
  5.  *    Written By: Phillip A. Kaufman                     November, 1987    *
  6.  *                                    *
  7.  *    Copyright 1987, 1988 Phillip A. Kaufman. All rights, except those    *
  8.  *    specifically granted herein are reserved by the author. The right    *
  9.  *    to copy and distribute this material is granted without fee for    *
  10.  *    any and all non-commercial use. This material specifically may    *
  11.  *    not be distributed or sold for a fee nor incorporated in whole or    *
  12.  *    in part into any other product that is distributed or sold for a    *
  13.  *    fee without specific permission of the author. To obtain special    *
  14.  *    permission or to report any difficulties with this material    *
  15.  *    contact:                                *
  16.  *                      Phillip A. Kaufman                *
  17.  *                      19987 Moran Lane                *
  18.  *                      Saratoga, CA 95070                *
  19.  *                                    *
  20.  *    THIS MATERIAL IS DISTRIBUTES "as is" WITHOUT ANY EXPRESSED OR    *
  21.  *    IMPLIED WARRANTY OR LIABILITY FOR DIRECT, INDIRECT OR        *
  22.  *    CONSEQUENTIAL DAMAGES.                        *
  23.  ************************************************************************
  24.  *      Inputs:                                *
  25.  *              Decimal Digits; 0 to 9                    *
  26.  *              Floating representation (+/-xxx.xxx) in decimal        *
  27.  *                      mode only.                    *
  28.  *              Hex digits;     A to F REPRESENTED BY Function keys    *
  29.  *              Ops;            + - * /  There is full chaining of ops    *
  30.  *              HEX and Binary Ops: And, Or, Xor              *
  31.  *                No chaining of logical ops        *
  32.  *              Change Sign #                        *
  33.  *              Memory; MClear, MRecall, M+, M-                *
  34.  *              Modes;          Hex, Decimal, Binary            *
  35.  *                      (hex and binary are integer only)        *
  36.  *              Clear Entry or Accum;           C            *
  37.  *              EXIT;           ESC                    *
  38.  ************************************************************************
  39.  *                       CALCULATOR SCREEN IMAGE                        *
  40.  *                                                                      *
  41.  *                  +------------------------------+                    *
  42.  *                0 |                              |                    *
  43.  *                1 |    MEMORY      +-----------+ |                    *
  44.  *                2 | 1234567890123  1234567890123 |                    *
  45.  *                3 |                +-----------+ |                    *
  46.  *                4 |                              |                    *
  47.  *                5 | MCLEAR    M-   DEC  HEX  BIN |                    *
  48.  *                6 |                              |                    *
  49.  *                7 | MRECALL   M+   AND  OR   XOR |                    *
  50.  *                8 |                              |                    *
  51.  *                9 | A(F5)   B(F6)    7  8  9   / |                    *
  52.  *               10 |                              |                    *
  53.  *               11 | C(F7)   D(F8)    4  5  6   * |                    *
  54.  *               12 |                              |                    *
  55.  *               13 | E(F9)   F(F10)   1  2  3   - |                    *
  56.  *               14 |                              |                    *
  57.  *               15 | CLEAR   +/-(#)   0  .  =   + |                    *
  58.  *               16 |                              |                    *
  59.  *                  +------------------------------+                    *
  60.  *                             11111111112222222222                     *
  61.  *                   012345678901234567890123456789                     *
  62.  *                                                                      *
  63.  *                                                                      *
  64.  ************************************************************************/
  65.  
  66. #include    <dos.h>
  67. #include     <stdio.h>
  68. #include    <setjmp.h>
  69. #include    <float.h>
  70. #include    <signal.h>
  71.  
  72.     /* colors may be changed to suit user */
  73. #define FG      0x07            /* forground color, unselected info     */
  74. #define BG      0x01            /* background color, main image         */
  75. #define HC      0x0a            /* highlight color, selectable keys     */
  76. #define WF      0x00            /* answer window FG color               */
  77. #define WB      0x07            /* answer window BG color               */
  78. #define SC      0x0f            /* selected info color                  */
  79. #define EC    0x06        /* error color                */
  80.  
  81. #define CASE    case
  82. #define DEFAULT default
  83. #define OK    1
  84. #define BAD    0
  85. #define TRUE    1
  86. #define FALSE    0
  87. #define YES    1
  88. #define    NO    0
  89.  
  90. #define ROWS    17        /* for convenience - do not change     */
  91. #define COLS    30
  92. #define ROW2    ROWS*2
  93. #define COL2    COLS*2
  94.  
  95. #define attr(f,b) (char)( (((b)&0x0F) << 4) | ((f)&0x0F) ) /*make attr byte*/
  96. #define apos(r,c) ((r)*COL2 + (c)*2)              /* memory offset of r,c */
  97.  
  98. #define MEMR    2        /* memory disp row        */
  99. #define MEMC    1        /* memory disp col        */
  100. #define ACCR    2        /* accum row            */
  101. #define ACCC    16        /* accum col            */
  102. #define MEMPOS  apos(MEMR,MEMC)       /* memory display position */
  103. #define ACPOS   apos(ACCR,ACCC)      /* accumulator display position */
  104. #define ANSLEN  13        /* answers string length    */
  105. #define ERRR    1        /* error display row        */
  106. #define ERRC    16        /* error display col        */
  107.  
  108. #define DEC 0            /* modes            */
  109. #define HEX 1
  110. #define BIN 2
  111. int mode = DEC;            /* startup mode            */
  112. unsigned char modeloc[3][2] = {5,16, 5,21, 5,26};
  113. unsigned char aoxloc[3][2] = {7,16, 7,21, 7,26};
  114.  
  115. /* All characters that appear statically highlighted */
  116. unsigned char hichar[][3] = {
  117.         5,1,'M',   5,2,'C',   5,11,'M',   5,12,'-',
  118.         5,16,'D',  5,21,'H',  5,26,'B',
  119.         7,1,'M',   7,2,'R',   7,11,'M',   7,12,'+',
  120.         7,16,'A',  7,21,'O',  7,26,'X',
  121.         9,3,'F',   9,4,'5',   9,11,'F',  9,12,'6',
  122.         9,18,'7',  9,21,'8',  9,24,'9',  9,28,'/',
  123.         11,3,'F',  11,4,'7',  11,11,'F', 11,12,'8',
  124.         11,18,'4', 11,21,'5', 11,24,'6', 11,28,'*',
  125.         13,3,'F',  13,4,'9',  13,11,'F', 13,12,'1', 13,13,'0',
  126.         13,18,'1', 13,21,'2', 13,24,'3', 13,28,'-',
  127.         15,1,'C',  15,13,'#',
  128.         15,18,'0', 15,21,'.', 15,24,'=', 15,28,'+',
  129.         0,0,0};          /* end marker */
  130.  
  131. /* All characters that appear statically not highlighted */
  132. unsigned char lochar[][3] = {
  133.         1,4,'M', 1,5,'E', 1,6,'M', 1,7,'O', 1,8,'R', 1,9,'Y',
  134.         5,3,'L', 5,4,'E', 5,5,'A',5,6,'R',
  135.         5,17,'E', 5,18,'C', 5,22,'E', 5,23,'X', 5,27,'I', 5,28,'N',
  136.         7,3,'E', 7,4,'C', 7,5,'A', 7,6,'L', 7,7,'L',
  137.         7,17,'N', 7,18,'D', 7,22,'R', 7,27,'O', 7,28,'R',
  138.         9,1,'A', 9,2,'(', 9,5,')', 9,9,'B', 9,10,'(', 9,13,')',
  139.         11,1,'C', 11,2,'(', 11,5,')', 11,9,'D', 11,10,'(', 11,13,')',
  140.         13,1,'E', 13,2,'(', 13,5,')', 13,9,'F', 13,10,'(', 13,14,')',
  141.         15,2,'L', 15,3,'E', 15,4,'A', 15,5,'R',
  142.         15,9,'+', 15,10,'/', 15,11,'-', 15,12,'(', 15,14,')',
  143.         0,0,0};
  144.         
  145. #define ERRLEN    11            /* number of chars in error msgs */
  146. char OVERFLOW[] = "OVERFLOW   ";    /* error messages        */
  147. char ZERODIV[]  = "DIVIDE BY 0";
  148. char BADKEY[]   = "ILLEGAL KEY";
  149. char FORMATERR[]= "FORMAT ERR ";
  150. char ENTLENGTH[]= "# TOO LONG ";
  151. char DISPOV[]   = "# TOO BIG  ";
  152. char NOERR[]    = "           ";
  153. char *errptr;                /* ptr to current error msg    */
  154.  
  155. union REGS rg;            /* cpu regs        */
  156. struct SREGS segregs;
  157. union{
  158.         long    l;
  159.         unsigned char far  *p;
  160. } addr;
  161.  
  162. char entry[ANSLEN+2];            /* entry string            */
  163. double faccum = 0.0;            /* accumulator            */
  164. double fsave = 0.0;            /* save for chaining        */
  165. double ftemp;                /* temp for calculations    */
  166. double fmemacc = 0.0;            /* memory accumulator        */
  167. char c;                    /* input key            */
  168. int oper;                /* last operator entered    */
  169. int memop;                /* last memory operator        */
  170. int equ;                /* an equal sign seen        */
  171. int collect;                    /* collecting digits        */
  172. int recall;                /* just did memory recall    */
  173.  
  174. #define MEMOP 0
  175. #define ACCOP 1
  176. int optype;                /* acc or mem for fp recovery    */
  177. int fphandler();               /* take care of floating errors     */
  178. jmp_buf mark;
  179.  
  180. main()
  181. {
  182.         register int i;
  183.         
  184.          dvinit();                      /* check dv, get display addr */
  185.         setrattr(attr(FG,BG),0,0,ROWS-1,COLS-1); /* full window attributes */
  186.         setrattr(attr(WF,WB),ACCR,ACCC,ACCR+1,ACCC+ANSLEN-1);
  187.                                   /* answer window attr      */
  188.         setrattr(attr(EC,WB),ERRR,ERRC,ERRR,ERRC+ANSLEN-1);     
  189.                              /* answer window attr,err  */
  190.         setrattr(attr(WF,WB),MEMR,MEMC,MEMR,MEMC+ANSLEN-1);      
  191.                              /* mem answer window attr  */
  192.         dispca(attr(HC,BG),hichar);          /* static highlight chars  */
  193.         dispca(attr(FG,BG),lochar);          /* static normal chars     */
  194.     errptr = NOERR;                      /* start error free    */
  195.     signal(SIGFPE,fphandler);
  196.     if (setjmp(mark) == -1 ){         /* here on fp error return    */
  197.         if (optype == ACCOP) faccum = 0.0;
  198.         if (optype == MEMOP) fmemacc = 0.0;
  199.         doerr();
  200.     }
  201.     oper = '\0';
  202.     memop = '\0';
  203.     equ = NO;
  204.     collect = NO;    
  205.     recall = NO;
  206.     optype = ACCOP;
  207.     
  208.         /* input scanner and computations */
  209.     while(1) {
  210.     display();                /* show accum and mem value */
  211.     setmode();                /* show current mode    */
  212.     memop = '\0';
  213.         c = getch();                /* wait, get char        */
  214.         c = toupper(c);
  215.         errptr = BADKEY;              /* assume bad key        */
  216.     if ( c == 'M'){                    /* memory ops         */
  217.                 errptr = NOERR;
  218.         c = getch();
  219.         c = toupper(c);
  220.                 switch (c) {
  221.             CASE '+':           /* M+ or M- get pushed as = */
  222.                         CASE '-':
  223.                                 memop = c;
  224.                                 c = '=';
  225.                                 break;
  226.                         CASE 'C':           /* MCLEAR */
  227.                                 fmemacc = 0.0;
  228.                 c = 0xFF;     /* don't want to see C again */
  229.                                 break;
  230.                         CASE 'R':           /* MRECALL */
  231.                 if (equ == NO) fsave = faccum;
  232.                                 faccum = fmemacc;
  233.                 recall = YES;    /* fake any entry */
  234.                 collect = YES;
  235.                                 break;
  236.             DEFAULT:
  237.                     errptr = BADKEY;    /* bad key    */
  238.                 c = 0xFF;    /* bad key sequence */
  239.                 }
  240.     }
  241.         switch (c) {
  242.         CASE 0x1B:            /* ESC ==> exit */
  243.             exit(0);
  244.         CASE '#':            /* Change Sign */
  245.             errptr = NOERR;
  246.             faccum = - faccum;
  247.             break;
  248.         CASE 'B':            /* binary mode */
  249.                         errptr = NOERR;
  250.                         mode = BIN;
  251.             collect = NO;
  252.             recall = NO;
  253.                         break;
  254.                 CASE 'C':               /* clear entry or accumulator */
  255.                         errptr = NOERR;
  256.                         if (collect){
  257.                                 faccum = 0.0;
  258.                         }
  259.                         else {
  260.                                 faccum = 0.0;
  261.                                 fsave = 0.0;
  262.                                 oper = '\0';
  263.                                 equ = NO;
  264.                         }
  265.             collect = NO;
  266.             recall = NO;
  267.                         break;
  268.                 CASE 'D':               /* set decimal mode */
  269.                         errptr = NOERR;
  270.                         if (oper == 'A' || oper == 'O' || oper == 'X')
  271.                                 oper = '\0';
  272.                         mode = DEC;
  273.             collect = NO;
  274.             recall = NO;
  275.                         break;
  276.                 CASE 'H':               /* set hex mode */
  277.                         errptr = NOERR;
  278.                         mode = HEX;
  279.             collect = NO;
  280.             recall = NO;
  281.                         break;
  282.                 CASE 'A':               /* logicals stack for = */
  283.                 CASE 'O':
  284.                 CASE 'X':
  285.                         if (mode != DEC){       /* no decimal logicals */
  286.                 collect = NO;
  287.                 recall = NO;
  288.                                 errptr = NOERR;
  289.                                 oper = c;
  290.                                 equ = NO;
  291.                         }
  292.                         break;
  293.                 CASE '+':
  294.                 CASE '-':
  295.                 CASE '*':               /* standard ops */
  296.                 CASE '/':
  297.                         errptr = NOERR;
  298.                         if (equ == NO && collect){   /* a pending op to do */
  299.                             ftemp = faccum;
  300.                             switch (oper) {
  301.                                 CASE '*':
  302.                                         faccum *= fsave;
  303.                                         break;
  304.                                 CASE '/':
  305.                                     if (faccum == 0.0)
  306.                                         errptr = ZERODIV;
  307.                                         else faccum = fsave / faccum;
  308.                                         break;
  309.                                 CASE '+':
  310.                                         faccum += fsave;
  311.                                         break;
  312.                                 CASE '-':
  313.                                         faccum = fsave - faccum;
  314.                             }
  315.                             fsave = ftemp;
  316.                         }
  317.             collect = NO;
  318.             recall = NO;
  319.                         oper = c;
  320.                         equ = NO;
  321.                         break;
  322.                 CASE '=':           /* execute and chain operations */
  323.                         errptr = NOERR;
  324.                 if (equ == NO || (collect && equ)){ /* pending op or
  325.                                      pending entry */
  326.                             ftemp = faccum;
  327.                             switch (oper){
  328.                                 CASE 'A':
  329.                                         faccum = (double)
  330.                                              ((long)fsave & (long)faccum);
  331.                                         break;
  332.                                 CASE 'O':
  333.                                         faccum = (double)
  334.                                             ((long)fsave | (long)faccum);
  335.                                         break;
  336.                                 CASE 'X':
  337.                                         faccum = (double)
  338.                                             ((long)fsave ^ (long)faccum);
  339.                                         break;
  340.                                 CASE '*':
  341.                                         ftemp = fsave;
  342.                                         if ((collect == NO) && (equ == NO))
  343.                                                 faccum *= faccum;
  344.                                         else
  345.                                                 faccum *= fsave;
  346.                                         break;
  347.                                 CASE '/':
  348.                                         if ((collect == NO) && (equ == NO))
  349.                                                 faccum = 1 / faccum;
  350.                                         else if (equ){
  351.                                             if (fsave == 0.0){
  352.                                                 errptr = ZERODIV;
  353.                                                 faccum = 0.0;
  354.                                             }
  355.                                                 else faccum = faccum / fsave;
  356.                     }
  357.                                         else {
  358.                                             if (faccum == 0.0){
  359.                                                 errptr = ZERODIV;
  360.                                                 faccum = 0.0;
  361.                                             }
  362.                                                 else faccum = fsave / faccum;
  363.                     }
  364.                                         break;
  365.                                 CASE '+':
  366.                                         faccum += fsave;
  367.                                         break;
  368.                                 CASE '-':
  369.                                         if (equ)
  370.                                                 faccum = faccum - fsave;
  371.                                         else
  372.                                                 faccum = fsave - faccum;
  373.                             }
  374.                 }
  375.                         if (equ == NO)
  376.                                 fsave = ftemp;
  377.                         equ = YES;
  378.                         collect = NO;
  379.                         recall = NO;
  380.                         switch (memop){
  381.                                 CASE '\0':
  382.                                         break;
  383.                                 CASE '+':
  384.                                 optype = MEMOP;
  385.                                         fmemacc = faccum + fmemacc;
  386.                     optype = ACCOP;
  387.                                         break;
  388.                                 CASE '-':
  389.                                     optype = MEMOP;
  390.                                         fmemacc = fmemacc - faccum;
  391.                                         optype = ACCOP;
  392.                         }
  393.                         memop = '\0';
  394.                         break;
  395.                 CASE '0':
  396.                 CASE '1':
  397.                         addchar();
  398.                         break;
  399.                 CASE '2':
  400.                 CASE '3':
  401.                 CASE '4':
  402.                 CASE '5':
  403.                 CASE '6':
  404.                 CASE '7':
  405.                 CASE '8':
  406.                 CASE '9':
  407.                         if ( mode != BIN) {
  408.                             addchar();
  409.                             break;
  410.                         }
  411.                 CASE '\0':              /* special keys */
  412.                         c = getch();        /* get 2nd part */
  413.                         if (mode != HEX) break;
  414.                         if ( c == 0x3F) c = 'A';    /* function key 5 */
  415.                         else if (c == 0x40) c = 'B';    /* f6 */
  416.                         else if (c == 0x41) c = 'C';    /* f7 */
  417.                         else if (c == 0x42) c = 'D';    /* f8 */
  418.                         else if (c == 0x43) c = 'E';    /* f9 */
  419.                         else if (c == 0x44) c = 'F';    /* f10 */
  420.                         else break;
  421.                         addchar();
  422.                         break;
  423.                 CASE '.':
  424.                         if (mode != DEC) break;
  425.                         addchar();
  426.                         break;
  427.                 CASE 0x53:          /* DEL (since follows 0 - not S) */
  428.                 CASE 0x08:          /* Back Space */
  429.                            errptr = NOERR;
  430.             if (collect == YES) {
  431.                             c = '\0';    /* delete flag */
  432.                             addchar();
  433.                         }
  434.         }
  435.     }
  436. }
  437.  
  438. /* set attributes for rectangle */
  439. setrattr(attrib, ulr, ulc, lrr, lrc) 
  440. unsigned char attrib,ulr,ulc,lrr,lrc;
  441. {
  442.         unsigned char far *ptr;
  443.         register int i, j;
  444.  
  445.         for ( i = ulr; i < lrr+1; i++){        /* rows counter     */
  446.         ptr = addr.p + 1 + apos(i,ulc);
  447.             for ( j = ulc; j < lrc+1; j++){    /* column position     */
  448.                     *ptr = attrib;
  449.                     ptr = ptr + 2;
  450.             }
  451.         }
  452.         return;
  453. }
  454.  
  455. /* display an array of characters with attributes */
  456. dispca(attrib,array)     
  457. unsigned char attrib;
  458. unsigned char *array;
  459. {
  460.         unsigned char far *ptr;
  461.  
  462.         while  (*(array) != 0 && *(array+1) != 0){
  463.                 ptr = addr.p + apos( *array,*(array+1) );
  464.                 *ptr = *(array+2);
  465.                 ptr++;
  466.                 *ptr = attrib;
  467.                 array = array +3;
  468.         }
  469.         return;
  470. }
  471.  
  472. setmode()
  473. {
  474.     int i, mattr;
  475.     for ( i = 0; i < 3; i++){
  476.         setrattr(attr(HC,BG),modeloc[i][0],modeloc[i][1],modeloc[i][0],
  477.             modeloc[i][1]);         /* highlight 1st mode letr*/
  478.         setrattr(attr(FG,BG),modeloc[i][0],modeloc[i][1]+1,
  479.             modeloc[i][0], modeloc[i][1]+2);   /* lowlight rest */
  480.     }
  481.     setrattr(attr(SC,BG),modeloc[mode][0],modeloc[mode][1],
  482.         modeloc[mode][0], modeloc[mode][1]+2);
  483.                     /* highlight select mode word */
  484.     if (mode == DEC) mattr = attr(FG,BG);
  485.     else mattr = attr(HC,BG);
  486.     for ( i = 0; i < 3; i++){    /* set allowed and/or/xor command */
  487.         setrattr(mattr,aoxloc[i][0],aoxloc[i][1],
  488.             aoxloc[i][0],aoxloc[i][1]);
  489.     }
  490.     return;
  491. }
  492.  
  493. addchar()    /* check and put an input character on entry string */
  494. {
  495.     register int i;
  496.     int elen;
  497.     double base;        /* base for conversion */
  498.     double atof();        /* return types */
  499.     static int dpoint;    /* saw a dp on this sequence */
  500.     
  501.     if (recall == YES) return;  /* can't modify mem recall */
  502.     errptr = NOERR;
  503.     if (collect == NO){    /* first char of entry so clear it out    */
  504.               if (equ == NO) fsave = faccum;
  505.          faccum = 0.0;
  506.          entry[0] = '\0';
  507.          dpoint = 0;
  508.     }
  509.     collect = YES;
  510.     elen = strlen(entry);
  511.     if (dpoint == 0 && entry[elen-1] == '.') entry[--elen] = '\0';
  512.     if ( c != '\0'){    /* check length on additions */
  513.         if ( (mode == HEX && elen == 8) ||
  514.                  (mode == DEC && dpoint == 0 && elen == ANSLEN -2) ||
  515.                  (elen == ANSLEN -1) ){
  516.                 errptr = ENTLENGTH;
  517.                 return;
  518.             }
  519.     }
  520.     if (c == '.'){
  521.         if (dpoint == 0) dpoint++;
  522.         else {
  523.             errptr = FORMATERR;
  524.             return;
  525.         }
  526.     }
  527.     if (c == '\0'){            /* delete a char */
  528.         if (elen != 0){
  529.             if (entry[--elen] == '.') dpoint--;
  530.             entry[elen] = '\0'; 
  531.                 if (elen == 0) { /* if last char del, set "0" */
  532.                     entry[0] = '0';
  533.                     elen = 1;
  534.                 }
  535.         }
  536.     }
  537.     else {                /* add a char */
  538.         if (elen == 1 && entry[0] == '0'){
  539.             if (c == '0') return;  /* no extra leading zeros */
  540.             else elen--;    /* take off leading zero */
  541.         }
  542.         entry[elen++] = c;
  543.         entry[elen] = '\0';
  544.     } 
  545.     if (mode == DEC) { 
  546.         faccum = atof(entry);
  547.     }
  548.     else {    
  549.         if (mode == HEX) base = 16.0;
  550.         if (mode == BIN) base = 2.0;
  551.         faccum = 0.0;
  552.         for ( i = 0; i < elen; i++){
  553.             faccum = faccum * base + ( (entry[i]<0x40)?
  554.                 entry[i] - 0x30 : entry[i] - 0x41 + 10 );
  555.         }
  556.     }
  557.     return;
  558. }
  559.  
  560. /* update memory and accum display */
  561. display()
  562. {
  563.     char abuf[30];
  564.     char mbuf[30];
  565.     char tbuf[30];
  566.     
  567.     unsigned char far *ptr;
  568.     register int i,j;
  569.     long int lint;
  570.         
  571.     if (mode == DEC){        
  572.             if (collect == NO || recall == YES){
  573.             sprintf(abuf,"% #12.11lf",faccum);
  574.             ffixup(abuf);
  575.             }
  576.             optype = MEMOP;
  577.         sprintf(mbuf,"% #12.11lf",fmemacc);
  578.         ffixup(mbuf);
  579.         optype = ACCOP;
  580.     }
  581.     else if (mode == HEX) {
  582.                 if (collect == NO || recall ==YES){
  583.             lint =  faccum;
  584.             faccum = (double)lint;
  585.             sprintf(abuf,"%13lX",lint);
  586.         }
  587.         optype = MEMOP;
  588.         lint = (long)fmemacc;
  589.         fmemacc = (double)lint;
  590.         sprintf(mbuf,"%13lX",lint);
  591.         optype = ACCOP;
  592.     }
  593.     else {
  594.         if (collect == NO || recall == YES){
  595.             i = (int)faccum;
  596.             faccum = (double)i;
  597.             itoa(i, tbuf, 2);
  598.             sfixup (tbuf, abuf);
  599.         }
  600.         optype = MEMOP;
  601.         i = (int)(fmemacc);
  602.         fmemacc = (double)i;
  603.         itoa(i, tbuf, 2);
  604.         sfixup (tbuf, mbuf);
  605.         optype = ACCOP;
  606.     }
  607.     if (collect == YES && recall == NO)
  608.                 sfixup (entry, abuf);  /* display entry string */
  609.     
  610.     ptr = addr.p + MEMPOS;
  611.     for (i = 0; i < 13; i++){
  612.         *ptr = mbuf[i];
  613.         ptr = ptr + 2;
  614.     }
  615.     ptr = addr.p + ACPOS;
  616.     for (i = 0; i < 13; i++){
  617.         *ptr = abuf[i];
  618.         ptr = ptr + 2;
  619.     }
  620.     doerr();
  621.     return;
  622. }
  623.  
  624. ffixup(buf)        /* display fixup for floating point */
  625. char *buf;
  626. {
  627.     register int i, dotpos, zeros;
  628.     char temp[14];
  629.     
  630.     for (i = 0; i <13 && buf[i] != '.'; i++);
  631.     dotpos = i;
  632.     if (dotpos >12){
  633.         errptr = DISPOV;
  634.         buf[12] = '>';
  635.         buf[13] = '\0';
  636.         doerr();
  637.         return;
  638.     }
  639.     for (i = 12; i >1 && buf[i] == '0'; i--);
  640.     if (i < 12){
  641.         zeros = 12 - i;    /* number of trailing zeros */
  642.         temp[0] = buf[0];
  643.         for (i = 1; i <= zeros; i++) 
  644.             temp[i] = ' ';
  645.         for (; i <13; i++)
  646.             temp[i] = buf[i-zeros];
  647.         strcpy (buf,temp);
  648.     }
  649.     return;
  650. }
  651.  
  652. sfixup(tbuf,obuf)        /* display fixup for strings */
  653. char *tbuf, *obuf;
  654. {
  655.     int x;
  656.     register int i,j;
  657.     
  658.     x = strlen(tbuf);
  659.     if (x > ANSLEN) {    /* too long, display with ">" */
  660.         errptr = DISPOV;
  661.         strncpy (obuf, tbuf, ANSLEN-1);
  662.         obuf[ANSLEN-1] = '>';
  663.     }
  664.     else {            /* right justify if short */
  665.         for (i = 0; i < ANSLEN-x; i++)  obuf[i] = ' ';
  666.         for (j = 0; i < ANSLEN; i++,j++) obuf[i] = tbuf[j];
  667.     }
  668.     return;
  669. }
  670.  
  671. doerr()        /* update display of error string */
  672. {
  673.     unsigned char far *ptr;
  674.     register int i;
  675.     ptr = addr.p + apos(ERRR,ERRC+1);
  676.     for (i = 0; i < ERRLEN ; i++){
  677.         *ptr = *(errptr+i);
  678.         ptr = ptr + 2;
  679.     }
  680.     return(OK);
  681. }
  682.  
  683. dvinit()        /* Check for Desqview and use its buffer */
  684. {
  685.         rg.x.ax = 0x2B01;           /* do date set as DV check */
  686.         rg.x.cx = 0x4445;               /* "DESQ"an illegal date */
  687.         rg.x.dx = 0x5351;
  688.         int86(0x21,&rg,&rg);
  689.         if (rg.h.al != 0xFF){        /* we are in desqview    */
  690.                 rg.h.ah = 0xFE;        /* dv get buff addr    */
  691.         int86(0x10,&rg,&rg);
  692.         segread(&segregs);
  693.                 addr.l=((unsigned long)segregs.es<<16)+(unsigned long)rg.x.di;
  694.         }
  695.     else {
  696.         cputs ("\x07Program requires DESQview!\n");
  697.         exit(1);
  698.     }
  699.  
  700.     /* put the cursor outside the window */
  701.     rg.h.ah = 0x2;
  702.     rg.h.bh = 0;
  703.     rg.x.dx = 0x151f;  /* row 24 col 79*/
  704.     int86(0x10,&rg,&rg);
  705.     return;
  706. }
  707.  
  708. int fphandler(sig,num)
  709.     int sig,num;
  710. {
  711.     if (num == FPE_ZERODIVIDE) errptr = ZERODIV;
  712.     else errptr = OVERFLOW;
  713.     doerr();
  714.     _fpreset();
  715.     longjmp(mark,-1);
  716. }
  717.  
  718. _setargv()        /* dummy since we use no command line args */
  719. {
  720. }
  721.  
  722. _setenvp()        /* dummy since we don't use environment variables */
  723. {
  724. }
  725.